﻿//#define  _CRT_SECURE_NO_WARNINGS
//#include <iostream>
//#include <vector>
//using namespace std;
//
////46. 全排列
//class Solution46 {
//public:
//    vector<vector<int>> ret;
//    vector<int> path;
//    vector<bool> vis;
//    //bool[6];
//    vector<vector<int>> permute(vector<int>& nums) {
//        vis.resize(nums.size());
//        dfs(nums, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        if (pos == nums.size())
//        {
//            ret.push_back(path);
//            return;
//        }
//        for (int i = 0; i < nums.size(); i++)
//        {
//            if (vis[i] == true) continue;
//            path.push_back(nums[i]);
//            vis[i] = true;
//
//            dfs(nums, pos + 1);
//            path.pop_back();
//            vis[i] = false;
//        }
//    }
//};
//
////78. 子集
//class Solution78 {
//public:
//    vector<int> path;
//    vector<vector<int>> ret;
//    vector<vector<int>> subsets(vector<int>& nums) {
//        dfs(nums, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        ret.push_back(path);
//        for (int i = pos; i < nums.size(); i++)
//        {
//            path.push_back(nums[i]);
//            //dfs(nums, pos + 1); // 这是不对的，因为在for里面，所以会创建nums.size() - pos 个栈帧
//            dfs(nums, i + 1);
//            path.pop_back();    //如果是dfs(nums, pos + 1) 那么每次都是进去 pos + 1，它不会变push_back的是变了
//                               //也就是i值变了，i当然要变了// 还差一点，为什么会变多，有那么点感觉是会变多了
//        }                          //也是成功想出来了，博客有图解
//    }
//};
////47. 全排列 II                             //去重想到的就是set
//#include <set>
//class Solution47 {
//public:
//    set<vector<int>> set;
//    vector<bool> vis;
//    vector<int> path;
//    vector<vector<int>> permuteUnique(vector<int>& nums) {
//        vis.resize(nums.size());
//        dfs(nums, 0);
//        vector<vector<int>> ret(set.begin(), set.end());
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        if (path.size() == nums.size())
//        {
//            set.insert(path);
//        }
//        for (int i = 0; i < nums.size(); i++)
//        {
//            if (vis[i]) continue;
//            path.push_back(nums[i]);
//            vis[i] = true;
//            dfs(nums, pos + 1);
//            vis[i] = false;
//            path.pop_back();
//        }
//    }
//};
//#include <algorithm>
//class Solution_47 {
//public:
//    vector<bool> vis;
//    vector<int> path;
//    vector<vector<int>> ret;
//    vector<vector<int>> permuteUnique(vector<int>& nums) {
//        vis.resize(nums.size());
//        sort(nums.begin(), nums.end());
//        dfs(nums, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        if (pos == nums.size())
//        {
//            ret.push_back(path);
//            return;
//        }
//        for (int i = 0; i < nums.size(); i++)
//        {
//            if (vis[i] == true ||            //i != 0 是为了不进去 nums[i - 1]
//                i != 0 && nums[i] == nums[i - 1] && vis[i - 1] == false) continue;
//
//            //if(vis[i] == false && nums[i] != nums[i - 1] || vis[i - 1] == true)
//            path.push_back(nums[i]);
//            vis[i] = true;
//            dfs(nums, pos + 1);
//            path.pop_back();
//            vis[i] = false;
//        }
//    }
//};
//
////17. 电话号码的字母组合
//// 代码问题：arr[digits[pos] - '0'];忘记是字符了
//
////逻辑问题：digiis可能是空串，空串进入dfs就会被压入 "" 空字符串
//class Solution17 {
//public:
//    vector<string> arr{ "","","abc","def" ,"ghi","jkl","mno","pqrs","tuv","wxyz"};
//    vector<string> ret;
//    string path;
//    vector<string> letterCombinations(string digits) {
//        dfs(digits, 0);
//        return ret;
//    }
//    void dfs(string digits, int pos)
//    {
//        if (pos == digits.size())
//        {
//            ret.push_back(path);
//            return;
//        }
//        string tmp = arr[digits[pos] - '0'];
//        for (auto e : tmp)
//        {
//            path.push_back(e);
//            dfs(digits, pos + 1);
//            path.pop_back();
//        }
//    }
//};
////22. 括号生成            不对
//#include <stack>
//class Solution22 {
//public:
//    stack<char> st;
//    string path;
//    vector<string> ret;
//    int k, m = 0, n = 0;
//
//    vector<string> generateParenthesis(int n) {
//        k = n;
//        dfs(0);
//        return ret;
//    }
//    void dfs(int pos)
//    {
//        if (path.size() == k * 2)
//        {
//            if (st.size() == 0 && m == n) ret.push_back(path);
//            return;
//        }
//        path += '(';
//        st.push('(');
//        m++;
//        dfs(pos + 1);
//        path.pop_back();
//        if(st.size())st.pop();
//        m--;
//
//        path += ')';
//        n++;
//        if(st.size()) st.pop();
//        dfs(pos + 1);
//        path.pop_back();
//        n--;
//    }
//};
//
////77. 组合
//class Solution77 {
//public:
//    vector<int> path;
//    vector<vector<int>> ret;
//    int _k, _n;
//    vector<vector<int>> combine(int n, int k) {
//        _k = k;
//        _n = n;
//        dfs(0);
//        return ret;
//    }
//    void dfs(int pos)
//    {
//        if (path.size() == _k)
//        {
//            ret.push_back(path);
//            return;
//        }
//        for (int i = pos; i < _n; i++)
//        {
//            path.push_back(i + 1);
//            dfs(i + 1);
//            path.pop_back();
//        }
//    }
//
//};
//
////494. 目标和
//class Solution494 {
//public: 
//    int ret = 0, _target;
//    int findTargetSumWays(vector<int>& nums, int target) {
//        _target = target;
//        dfs(nums, 0, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos, int sum)
//    {
//        if (pos == nums.size())
//        {
//            if (_target == sum)
//                ret++;
//            return;
//        }
//        /*ret += nums[pos];                  //写的什么玩意，怎么操作ret了
//        dfs(nums, pos + 1);
//        ret -= nums[pos];
//
//        ret -= nums[pos];*/
//        //dfs(nums, pos + 1);
//        sum += nums[pos];
//        dfs(nums, pos + 1, sum);
//        sum -= nums[pos];
//
//        sum -= nums[pos];
//        dfs(nums, pos + 1, sum);
//        sum += nums[pos];
//    }
//};
//
////39. 组合总和                   //就是子集的意思
//class Solution39 {                  //超时
//public:
//    //vector<vector<int>> ret;
//    int _target, sum = 0;
//    vector<int> path;
//    set<vector<int>> set;
//    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
//        vector<int> nums;
//        for (auto e : candidates)
//        {
//            int n = target / e;
//            for (int i = 0; i < n; i++)
//                nums.push_back(e);
//        }
//        _target = target;
//        dfs(nums, 0);
//        vector<vector<int>> ret(set.begin(), set.end());
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        if(sum == _target)
//            set.insert(path);
//        if (pos == nums.size()) return;
//
//        for (int i = pos; i < nums.size(); i++)
//        {
//            path.push_back(nums[i]);
//            sum += nums[i];
//            dfs(nums, i + 1);
//
//            sum -= nums[i];
//            path.pop_back();
//        }
//
//    }
//};
//
//class Solution39_ {//还是超时
//public:
//    vector<vector<int>> ret;
//    int _target, sum = 0;
//    vector<int> path;
//    //set<vector<int>> set;
//    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
//        vector<int> nums;
//        for (auto& e : candidates)
//        {
//            int n = target / e;
//            for (int i = 0; i < n; i++)
//                nums.push_back(e);
//        }
//        _target = target;
//        dfs(nums, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        if (sum == _target)
//            ret.push_back(path);
//        if (pos == nums.size()) return;
//
//        for (int i = pos; i < nums.size(); i++)
//        {
//            if(sum < _target)
//                path.push_back(nums[i]);
//            sum += nums[i];
//            dfs(nums, i + 1);
//
//            sum -= nums[i];
//            path.pop_back();
//        }
//
//    }
//};
//
////22. 括号生成
//class Solution_22 {
//public:
//    string path;
//    vector<string> ret;
//    int _n, left = 0, right = 0;
//    vector<string> generateParenthesis(int n) {
//        _n = n;
//        dfs();
//        return ret;
//    }
//    void dfs()
//    {
//        if (left == _n) return;
//        if (right == _n)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (left < _n) path.push_back('(');//如果分开，回来之后就pop那不就没有push吗！
//        left++, dfs();
//        path.pop_back(); left--;
//
//        if (right < left) path.push_back(')');
//        right++, dfs();
//        path.pop_back(); right--;
//    }
//
//};
//class Solution__22 {
//public:
//    string path;
//    vector<string> ret;
//    int _n, left = 0, right = 0;
//    vector<string> generateParenthesis(int n) {
//        _n = n;
//        dfs();
//        return ret;
//    }
//    void dfs()
//    {
//        if (left == _n) return;
//        if (right == _n)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (left < _n) ///为什么它是一套操作？
//        {
//            path.push_back('(');
//            left++, dfs();
//            path.pop_back(); left--;
//        }
//
//        if (right < left)
//        {
//            path.push_back(')');
//            right++, dfs();
//            path.pop_back(); right--;
//        }
//            
//    }
//
//};
//
////39. 组合总和
//
//class Solution__39 {                                                 //sum局部
//public:
//    vector<int> path;
//    int _target;
//    vector<vector<int>> ret;
//    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
//        _target = target;
//        dfs(candidates, 0, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos, int sum)
//    {
//        if (sum == _target)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (sum > _target || pos == nums.size()) return;
//        for (int i = 0; i * nums[pos] + sum <= _target; i++)
//        {
//            if (i) path.push_back(nums[pos]);      //少了没有第一个数的情况 if (i)这样解决
//            dfs(nums, pos + 1, i * nums[pos] + sum);
//            // while(i--)
//            //     path.pop_back();
//        }
//        for (int i = 1; i * nums[pos] + sum <= _target; i++) path.pop_back(); //没有=是怎么弹的？
//    }
//};
////没有=是怎么弹的？
////没有=是怎么弹的？
////没有=是怎么弹的？
////没有=是怎么弹的？
////没有=是怎么弹的？
////没有=是怎么弹的？
////没有=是怎么弹的？
////没有=是怎么弹的？          //答：不弹
//class Solution___39 {                                              //sum全局
//public:
//    vector<int> path;
//    int _target, sum;
//    vector<vector<int>> ret;
//    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
//        _target = target;
//        dfs(candidates, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        if (sum == _target)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (sum > _target || pos == nums.size()) return;
//        for (int i = 0; i * nums[pos] + sum <= _target; i++)
//        {
//            if (i) path.push_back(nums[pos]);      //少了没有第一个数的情况 if (i)这样解决
//            dfs(nums, pos + 1);
//            // while(i--)
//            //     path.pop_back();
//        }
//        for (int i = 1; i * nums[pos] + sum < _target; i++) path.pop_back(), sum -= nums[pos];
//    }
//};
//int main1()
//{
//    //vector<int> nums{1, 1, 2};
//    //Solution78().subsets(nums);
//    
//    
//    //string str;
//    //Solution17().letterCombinations(str);
//
//    //Solution22().generateParenthesis(2);
//
//    //Solution77().combine(4, 2);
//
//    //vector<int> nums{1, 1, 1, 1, 1};
//    //Solution494().findTargetSumWays(nums, 3);
//    
//    //Solution_47().permuteUnique(nums);
//
//    //Solution__22().generateParenthesis(3);
//
//    vector<int> nums{2,3,6,7};
//
//    Solution__39().combinationSum(nums, 7);
//    return 0; 
//}
//
//    
////重新悟
//
////47. 全排列 II
//class Solution472 {
//public:
//    vector<vector<int>> ret;
//    vector<int> path;
//    vector<bool> vis;
//    vector<vector<int>> permuteUnique(vector<int>& nums) {
//        sort(nums.begin(), nums.end());                      //这一步没有，只对一半
//        vis.resize(nums.size());               //没有sort 那么nums[i] == nums[i - 1]没有用，因为他要往前找相同的
//        dfs(nums, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        if (pos == nums.size())
//        {
//            ret.push_back(path);
//            return;
//        }
//        for (int i = 0; i < nums.size(); i++)  
//        {
//            if (vis[i] == true || i != 0 && nums[i] == nums[i - 1] && vis[i - 1] == false) continue;
//            path.push_back(nums[i]);
//            vis[i] = true;
//            dfs(nums, pos + 1);
//            path.pop_back();
//            vis[i] = false;
//        }
//    }
//};
//
////22. 括号生成
//class Solution222 {                    // 有条件的全排列 ，这里的n就有vis的作用
//public:
//    string path;
//    vector<string> ret;
//    int n, left = 0, right = 0;
//    vector<string> generateParenthesis(int _n) {
//        n = _n;
//        dfs();
//        return ret;
//    }
//    void dfs()
//    {
//        if (right == n)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (left < n)
//        {
//            path += '(';
//            left++;
//            dfs();
//            path.pop_back();
//            left--;
//        }
//
//        if (right < left)
//        {
//            path += ')';
//            right++;
//            dfs();
//            path.pop_back();
//            right--;
//        }
//    }
//};
//
////77. 组合                              //改了挺久                //集合的变形
//class Solution777 {
//public:
//    vector<vector<int>> ret;
//    int n, k;
//    vector<int> path;
//    vector<bool> vis;
//    vector<vector<int>> combine(int _n, int _k) {
//        //int n = _n, k = _k;                              //这样的话，那么外面的就没有赋值到
//        n = _n, k = _k;                          
//        vis.resize(n);
//        dfs(0);
//        return ret;
//    }
//    void dfs(int pos)
//    {
//        if (path.size() == k)              //size是出口，想成集合的开始用的深度
//        {
//            ret.push_back(path);
//            return;
//        }
//        for (int i = pos + 1; i <= n; i++)
//        {
//            if (vis[i - 1]) continue;
//            path.push_back(i);
//            vis[i - 1] = true;
//            //dfs(i + 1);            //这是dfs(i)
//            dfs(i);
//            path.pop_back();
//            vis[i - 1] = false;
//        }
//    }
//};
//class Solution7727 {                  //确实不需要vis了for里的i就已经控制了
//public:
//    vector<vector<int>> ret;
//    int n, k;
//    vector<int> path;
//    vector<vector<int>> combine(int _n, int _k) {
//        //int n = _n, k = _k;                              //这样的话，那么外面的就没有赋值到
//        n = _n, k = _k;
//        dfs(0);
//        return ret;
//    }
//    void dfs(int pos)
//    {
//        if (path.size() == k)
//        {
//            ret.push_back(path);
//            return;
//        }
//        for (int i = pos + 1; i <= n; i++)
//        {
//            path.push_back(i);
//            dfs(i);
//            path.pop_back();
//        }
//    }
//};
//
////39. 组合总和
//class Solution399 {
//public:
//    vector<vector<int>> ret;
//    vector<int> path;
//    int target, sum;      //有sum下面 -=的逻辑不行，减不掉
//    vector<vector<int>> combinationSum(vector<int>& candidates, int _target) {
//        target = _target;
//        dfs(candidates, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos)
//    {
//        if (sum == target)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (sum > target || pos >= nums.size()) return;  //防止越界解引用
//        for (int i = 0; sum + i * nums[pos] <= target; i++)
//        {
//            if (i) path.push_back(nums[pos]), sum += nums[pos];
//            dfs(nums, pos + 1);
//        }
//        for (int i = 1; sum + i * nums[pos] <= target; i++)
//            path.pop_back(), sum -= nums[pos];
//    }
//};
//class Solution {
//public:
//    vector<vector<int>> ret;
//    vector<int> path;
//    int target;
//    vector<vector<int>> combinationSum(vector<int>& candidates, int _target) {
//        target = _target;
//        dfs(candidates, 0, 0);
//        return ret;
//    }
//    void dfs(vector<int>& nums, int pos, int sum)
//    {
//        if (sum == target)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (sum > target || pos >= nums.size()) return;  //防止越界解引用
//        for (int i = 0; sum + i * nums[pos] <= target; i++)   //如果这么改，这里也矛盾，条件变成这一层加上这一层
//        {
//            //if (i) path.push_back(nums[pos])/*, sum += nums[pos]*/;    //加了这句当前的sum的传下去的都不对
//            //dfs(nums, pos + 1, sum + i * nums[pos]);
//            if (i) path.push_back(nums[pos]), sum += nums[pos]; //sum 是上一层栈帧传递到下一层
//            dfs(nums, pos + 1, sum);
//        }
//        //for (int i = 0; i * nums[pos] <= target; i++)   //果然问题就是665行那样，这样sum就是当前的
//        //{
//        //    if (i) path.push_back(nums[pos]), sum += nums[pos];
//        //    dfs(nums, pos + 1, sum);
//        //}
//        //for (int i = 1; i * nums[pos] <= target; i++)
//        //    path.pop_back();
//
//        for (int i = 1; sum <= target; i++)
//            path.pop_back();
//    }
//};
////明天试试全局的sum 和 组合总和 2 3 4
//int main2()
//{
//    //Solution().combine(4, 2);         //不写return 0 也会 return 0
//    vector<int> nums{2, 3, 6, 7};
//    Solution().combinationSum(nums, 7);
//    return 0;
//}
////
//
////今天晚上有点累，总结的不是很好
////40. 组合总和 II
//
//class Solution40 {
//public:
//    vector<vector<int>> ret;
//    vector<int> path;
//    int target, sum;
//    void dfs(vector<int>& nums, int deep)
//    {
//        if (sum == target)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (sum > target) return;
//        for (int i = deep; i < nums.size(); i++)  //这里的i = deep和下面dfs(i + 1)可以去重部分，防止往回找
//        {
//            if (i > deep && nums[i] == nums[i - 1]) continue; //避免了在同一栈帧中重复使用，且在不同栈帧中可以使用相同元素的牛逼操作
//            path.push_back(nums[i]);
//            sum += nums[i];
//            dfs(nums, i + 1);
//            path.pop_back();
//            sum -= nums[i];
//        }
//    }
//    vector<vector<int>> combinationSum2(vector<int>& candidates, int _target) {
//        sort(candidates.begin(), candidates.end());
//        target = _target;
//        dfs(candidates, 0);
//        return ret;
//    }
//};
////216. 组合总和 III
//class Solution216 {
//public:
//    vector<vector<int>> ret;
//    vector<int> path;
//    int sum, k, target;
//    void dfs(int deep)
//    {
//        if (path.size() == k && sum == target)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (sum > target || path.size() > k) return;  //发现大的后面再加上去都是大了，直接让i = 10 跳出，确实，用break更好
//        for (int i = deep + 1; i <= 9; i++)
//        {
//            path.push_back(i);
//            sum += i;        //出现ret为空的问题，果然细节上问题
//            dfs(i);           //逻辑出错了，dfs(i + 1) 上面的 i 已经完成了+1操作 
//            path.pop_back();
//            sum -= i;
//        }
//    }
//    vector<vector<int>> combinationSum3(int _k, int _n) {
//        k = _k, target = _n;
//        dfs(0);
//        return ret;
//    }
//};
//
////377. 组合总和 Ⅳ
//class Solution377 {            //超时，所以说题目说的是返回个数
//public:
//    int ret, target, sum;
//    void dfs(vector<int>& nums)
//    {
//        if (sum == target)
//        {
//            ret++;
//            return;
//        }
//        if (sum > target) return;
//
//        for (int i = 0; i < nums.size(); i++)
//        {
//            sum += nums[i];
//            dfs(nums);
//            sum -= nums[i];
//        }
//    }
//    int combinationSum4(vector<int>& nums, int _target) {
//        target = _target;
//        dfs(nums);
//        return ret;
//    }
//};
//class Solution3214 {
//public:
//    vector<vector<int>> ret;
//    vector<int> path;
//    int sum, target;
//    void dfs(vector<int>& nums, int pos)
//    {
//        if (sum == target)
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (sum > target || pos == nums.size()) return;
//        for (int i = pos; sum < target; i++)
//        {
//            if (i) sum += nums[pos], path.push_back(nums[pos]);
//            dfs(nums, pos + 1);
//        }
//        for (int i = 1; sum < target; i++)
//            sum -= nums[pos], path.pop_back();  //全局sum弹的时候出问题
//    }
//    int combinationSum4(vector<int>& nums, int _target) {
//        target = _target;
//        dfs(nums, 0);
//
//    }
//};
//class Solution11111 {                       //牛逼
//public:
//    int combinationSum4(vector<int>& nums, int target) {
//        vector<unsigned int> dp(target + 1, 0); // 使用unsigned int防止溢出
//        dp[0] = 1; // 初始化条件
//        for (int i = 1; i <= target; ++i) {
//            for (int num : nums) {
//                if (i >= num) {
//                    dp[i] += dp[i - num];     //插入的延续，第一次见
//                }
//            }
//        }
//        return dp[target];
//    }
//};
//
//// 784. 字母大小写全排列 (一遍过)
//
//class Solution784 {
//public:
//    vector<string> ret;
//    string path;
//    void dfs(string& s, int pos) //pos代表的是第每个char
//    {
//        if (path.size() == s.size())
//        {
//            ret.push_back(path);
//            return;
//        }
//        if (isdigit(s[pos]))
//        {
//            path.push_back(s[pos]);
//            dfs(s, pos + 1);
//            path.pop_back();
//        }
//        else
//        {
//            path.push_back(tolower(s[pos]));
//            dfs(s, pos + 1);
//            path.pop_back();
//
//            path.push_back(toupper(s[pos]));
//            dfs(s, pos + 1);
//            path.pop_back();
//        }
//    }
//    vector<string> letterCasePermutation(string s) {
//        dfs(s, 0);
//        return ret;
//    }
//};
////526. 优美的排列
//class Solution526 {
//public:
//    int ret, n;
//    vector<bool> vis;
//    void dfs(int deep)
//    {
//        if (deep == n + 1)
//        {
//            ret++;
//            return;
//        }
//        for (int i = 1; i <= n; i++)
//        {
//            //if (vis[i] && (i % deep && deep % i)) continue;
//            if (vis[i] || (i % deep && deep % i)) continue;  //没错，这地方是|| 前面的true了自己滚出这层for
//            vis[i] = true;
//            dfs(deep + 1);
//            vis[i] = false;           //这里呈现的逻辑和我想呈现的不一样
//        }
//
//        for (int i = 1; i <= n; i++)   //正确逻辑改出来了
//        {
//            if (!vis[i] && (i % deep == 0 || deep % i == 0))
//                vis[i] = true,
//                dfs(deep + 1);
//            else continue;
//            vis[i] = false;           //这里呈现的逻辑和我想呈现的不一样
//        }
//
//    }
//    int countArrangement(int _n) {
//        n = _n;
//        vis.resize(n + 1);
//        dfs(1);
//        return ret;
//    }
//};
////int main()
////{
////    vector<int> nums{1, 2, 3};
////    //Solution40().combinationSum2(nums, 8);
////    //Solution216().combinationSum3(3, 7);
////    //Solution377().combinationSum4(nums, 32);
////    //Solution11111().combinationSum4(nums, 4);
////    Solution526().countArrangement(3);
////    return 0;
////}